index 14955f8..84311bf 100644
--- a/crates/bindings/bevy_reflect_bms_bindings/src/lib.rs
+++ b/crates/bindings/bevy_reflect_bms_bindings/src/lib.rs
@@ -3160,6 +3160,23 @@ pub(crate) fn register_vec_3_functions(world: &mut World) {
             " Returns a vector containing `e^self` (the exponential function) for each element of\n `self`.",
             &["_self"],
         )
+        .register_documented(
+            "exp2",
+            |_self: Val<::glam::Vec3>| {
+                let output: Val<::glam::Vec3> = {
+                    {
+                        let output: Val<::glam::Vec3> = ::glam::Vec3::exp2(
+                                _self.into_inner(),
+                            )
+                            .into();
+                        output
+                    }
+                };
+                output
+            },
+            " Returns a vector containing `2^self` for each element of `self`.",
+            &["_self"],
+        )
         .register_documented(
             "extend",
             |_self: Val<::glam::Vec3>, w: f32| {
@@ -3244,6 +3261,23 @@ pub(crate) fn register_vec_3_functions(world: &mut World) {
             " Creates a new vector from an array.",
             &["a"],
         )
+        .register_documented(
+            "from_homogeneous",
+            |v: Val<::glam::Vec4>| {
+                let output: Val<::glam::Vec3> = {
+                    {
+                        let output: Val<::glam::Vec3> = ::glam::Vec3::from_homogeneous(
+                                v.into_inner(),
+                            )
+                            .into();
+                        output
+                    }
+                };
+                output
+            },
+            " Projects a homogeneous coordinate to 3D space by performing perspective divide.\n # Panics\n Will panic if `v.w` is `0` when `glam_assert` is enabled.",
+            &["v"],
+        )
         .register_documented(
             "is_finite",
             |_self: Val<::glam::Vec3>| {
@@ -3408,6 +3442,40 @@ pub(crate) fn register_vec_3_functions(world: &mut World) {
             " Performs a linear interpolation between `self` and `rhs` based on the value `s`.\n When `s` is `0.0`, the result will be equal to `self`.  When `s` is `1.0`, the result\n will be equal to `rhs`. When `s` is outside of range `[0, 1]`, the result is linearly\n extrapolated.",
             &["_self", "rhs", "s"],
         )
+        .register_documented(
+            "ln",
+            |_self: Val<::glam::Vec3>| {
+                let output: Val<::glam::Vec3> = {
+                    {
+                        let output: Val<::glam::Vec3> = ::glam::Vec3::ln(
+                                _self.into_inner(),
+                            )
+                            .into();
+                        output
+                    }
+                };
+                output
+            },
+            " Returns a vector containing the natural logarithm for each element of `self`.\n This returns NaN when the element is negative and negative infinity when the element is zero.",
+            &["_self"],
+        )
+        .register_documented(
+            "log2",
+            |_self: Val<::glam::Vec3>| {
+                let output: Val<::glam::Vec3> = {
+                    {
+                        let output: Val<::glam::Vec3> = ::glam::Vec3::log2(
+                                _self.into_inner(),
+                            )
+                            .into();
+                        output
+                    }
+                };
+                output
+            },
+            " Returns a vector containing the base 2 logarithm for each element of `self`.\n This returns NaN when the element is negative and negative infinity when the element is zero.",
+            &["_self"],
+        )
         .register_documented(
             "max",
             |_self: Val<::glam::Vec3>, rhs: Val<::glam::Vec3>| {
@@ -4159,6 +4227,23 @@ pub(crate) fn register_vec_3_functions(world: &mut World) {
             " Converts `self` to `[x, y, z]`",
             &["_self"],
         )
+        .register_documented(
+            "to_homogeneous",
+            |_self: Val<::glam::Vec3>| {
+                let output: Val<::glam::Vec4> = {
+                    {
+                        let output: Val<::glam::Vec4> = ::glam::Vec3::to_homogeneous(
+                                _self.into_inner(),
+                            )
+                            .into();
+                        output
+                    }
+                };
+                output
+            },
+            " Creates a homogeneous coordinate from `self`, equivalent to `self.extend(1.0)`.",
+            &["_self"],
+        )
         .register_documented(
             "to_vec3a",
             |_self: Val<::glam::Vec3>| {
@@ -35692,6 +35777,23 @@ pub(crate) fn register_vec_2_functions(world: &mut World) {
             " Returns a vector containing `e^self` (the exponential function) for each element of\n `self`.",
             &["_self"],
         )
+        .register_documented(
+            "exp2",
+            |_self: Val<::glam::Vec2>| {
+                let output: Val<::glam::Vec2> = {
+                    {
+                        let output: Val<::glam::Vec2> = ::glam::Vec2::exp2(
+                                _self.into_inner(),
+                            )
+                            .into();
+                        output
+                    }
+                };
+                output
+            },
+            " Returns a vector containing `2^self` for each element of `self`.",
+            &["_self"],
+        )
         .register_documented(
             "extend",
             |_self: Val<::glam::Vec2>, z: f32| {
@@ -35955,6 +36057,40 @@ pub(crate) fn register_vec_2_functions(world: &mut World) {
             " Performs a linear interpolation between `self` and `rhs` based on the value `s`.\n When `s` is `0.0`, the result will be equal to `self`.  When `s` is `1.0`, the result\n will be equal to `rhs`. When `s` is outside of range `[0, 1]`, the result is linearly\n extrapolated.",
             &["_self", "rhs", "s"],
         )
+        .register_documented(
+            "ln",
+            |_self: Val<::glam::Vec2>| {
+                let output: Val<::glam::Vec2> = {
+                    {
+                        let output: Val<::glam::Vec2> = ::glam::Vec2::ln(
+                                _self.into_inner(),
+                            )
+                            .into();
+                        output
+                    }
+                };
+                output
+            },
+            " Returns a vector containing the natural logarithm for each element of `self`.\n This returns NaN when the element is negative and negative infinity when the element is zero.",
+            &["_self"],
+        )
+        .register_documented(
+            "log2",
+            |_self: Val<::glam::Vec2>| {
+                let output: Val<::glam::Vec2> = {
+                    {
+                        let output: Val<::glam::Vec2> = ::glam::Vec2::log2(
+                                _self.into_inner(),
+                            )
+                            .into();
+                        output
+                    }
+                };
+                output
+            },
+            " Returns a vector containing the base 2 logarithm for each element of `self`.\n This returns NaN when the element is negative and negative infinity when the element is zero.",
+            &["_self"],
+        )
         .register_documented(
             "max",
             |_self: Val<::glam::Vec2>, rhs: Val<::glam::Vec2>| {
@@ -37491,6 +37627,23 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) {
             " Returns a vector containing `e^self` (the exponential function) for each element of\n `self`.",
             &["_self"],
         )
+        .register_documented(
+            "exp2",
+            |_self: Val<::glam::Vec3A>| {
+                let output: Val<::glam::Vec3A> = {
+                    {
+                        let output: Val<::glam::Vec3A> = ::glam::Vec3A::exp2(
+                                _self.into_inner(),
+                            )
+                            .into();
+                        output
+                    }
+                };
+                output
+            },
+            " Returns a vector containing `2^self` for each element of `self`.",
+            &["_self"],
+        )
         .register_documented(
             "extend",
             |_self: Val<::glam::Vec3A>, w: f32| {
@@ -37575,6 +37728,23 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) {
             " Creates a new vector from an array.",
             &["a"],
         )
+        .register_documented(
+            "from_homogeneous",
+            |v: Val<::glam::Vec4>| {
+                let output: Val<::glam::Vec3A> = {
+                    {
+                        let output: Val<::glam::Vec3A> = ::glam::Vec3A::from_homogeneous(
+                                v.into_inner(),
+                            )
+                            .into();
+                        output
+                    }
+                };
+                output
+            },
+            " Projects a homogeneous coordinate to 3D space by performing perspective divide.\n # Panics\n Will panic if `v.w` is `0` when `glam_assert` is enabled.",
+            &["v"],
+        )
         .register_documented(
             "from_vec4",
             |v: Val<::glam::Vec4>| {
@@ -37756,6 +37926,40 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) {
             " Performs a linear interpolation between `self` and `rhs` based on the value `s`.\n When `s` is `0.0`, the result will be equal to `self`.  When `s` is `1.0`, the result\n will be equal to `rhs`. When `s` is outside of range `[0, 1]`, the result is linearly\n extrapolated.",
             &["_self", "rhs", "s"],
         )
+        .register_documented(
+            "ln",
+            |_self: Val<::glam::Vec3A>| {
+                let output: Val<::glam::Vec3A> = {
+                    {
+                        let output: Val<::glam::Vec3A> = ::glam::Vec3A::ln(
+                                _self.into_inner(),
+                            )
+                            .into();
+                        output
+                    }
+                };
+                output
+            },
+            " Returns a vector containing the natural logarithm for each element of `self`.\n This returns NaN when the element is negative and negative infinity when the element is zero.",
+            &["_self"],
+        )
+        .register_documented(
+            "log2",
+            |_self: Val<::glam::Vec3A>| {
+                let output: Val<::glam::Vec3A> = {
+                    {
+                        let output: Val<::glam::Vec3A> = ::glam::Vec3A::log2(
+                                _self.into_inner(),
+                            )
+                            .into();
+                        output
+                    }
+                };
+                output
+            },
+            " Returns a vector containing the base 2 logarithm for each element of `self`.\n This returns NaN when the element is negative and negative infinity when the element is zero.",
+            &["_self"],
+        )
         .register_documented(
             "max",
             |_self: Val<::glam::Vec3A>, rhs: Val<::glam::Vec3A>| {
@@ -38507,6 +38711,23 @@ pub(crate) fn register_vec_3_a_functions(world: &mut World) {
             " Converts `self` to `[x, y, z]`",
             &["_self"],
         )
+        .register_documented(
+            "to_homogeneous",
+            |_self: Val<::glam::Vec3A>| {
+                let output: Val<::glam::Vec4> = {
+                    {
+                        let output: Val<::glam::Vec4> = ::glam::Vec3A::to_homogeneous(
+                                _self.into_inner(),
+                            )
+                            .into();
+                        output
+                    }
+                };
+                output
+            },
+            " Creates a homogeneous coordinate from `self`, equivalent to `self.extend(1.0)`.",
+            &["_self"],
+        )
         .register_documented(
             "to_vec3",
             |_self: Val<::glam::Vec3A>| {
@@ -39291,6 +39512,23 @@ pub(crate) fn register_vec_4_functions(world: &mut World) {
             " Returns a vector containing `e^self` (the exponential function) for each element of\n `self`.",
             &["_self"],
         )
+        .register_documented(
+            "exp2",
+            |_self: Val<::glam::Vec4>| {
+                let output: Val<::glam::Vec4> = {
+                    {
+                        let output: Val<::glam::Vec4> = ::glam::Vec4::exp2(
+                                _self.into_inner(),
+                            )
+                            .into();
+                        output
+                    }
+                };
+                output
+            },
+            " Returns a vector containing `2^self` for each element of `self`.",
+            &["_self"],
+        )
         .register_documented(
             "floor",
             |_self: Val<::glam::Vec4>| {
@@ -39521,6 +39759,40 @@ pub(crate) fn register_vec_4_functions(world: &mut World) {
             " Performs a linear interpolation between `self` and `rhs` based on the value `s`.\n When `s` is `0.0`, the result will be equal to `self`.  When `s` is `1.0`, the result\n will be equal to `rhs`. When `s` is outside of range `[0, 1]`, the result is linearly\n extrapolated.",
             &["_self", "rhs", "s"],
         )
+        .register_documented(
+            "ln",
+            |_self: Val<::glam::Vec4>| {
+                let output: Val<::glam::Vec4> = {
+                    {
+                        let output: Val<::glam::Vec4> = ::glam::Vec4::ln(
+                                _self.into_inner(),
+                            )
+                            .into();
+                        output
+                    }
+                };
+                output
+            },
+            " Returns a vector containing the natural logarithm for each element of `self`.\n This returns NaN when the element is negative and negative infinity when the element is zero.",
+            &["_self"],
+        )
+        .register_documented(
+            "log2",
+            |_self: Val<::glam::Vec4>| {
+                let output: Val<::glam::Vec4> = {
+                    {
+                        let output: Val<::glam::Vec4> = ::glam::Vec4::log2(
+                                _self.into_inner(),
+                            )
+                            .into();
+                        output
+                    }
+                };
+                output
+            },
+            " Returns a vector containing the base 2 logarithm for each element of `self`.\n This returns NaN when the element is negative and negative infinity when the element is zero.",
+            &["_self"],
+        )
         .register_documented(
             "max",
             |_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>| {
@@ -39830,6 +40102,23 @@ pub(crate) fn register_vec_4_functions(world: &mut World) {
             " Returns a vector containing each element of `self` raised to the power of `n`.",
             &["_self", "n"],
         )
+        .register_documented(
+            "project",
+            |_self: Val<::glam::Vec4>| {
+                let output: Val<::glam::Vec3> = {
+                    {
+                        let output: Val<::glam::Vec3> = ::glam::Vec4::project(
+                                _self.into_inner(),
+                            )
+                            .into();
+                        output
+                    }
+                };
+                output
+            },
+            " Projects a homogeneous coordinate to 3D space by performing perspective divide.\n To project to [`Vec3A`] use [`Vec3A::from_homogeneous()`].\n # Panics\n Will panic if `self.w` is `0` when `glam_assert` is enabled.",
+            &["_self"],
+        )
         .register_documented(
             "project_onto",
             |_self: Val<::glam::Vec4>, rhs: Val<::glam::Vec4>| {
@@ -41514,6 +41803,23 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) {
             " Returns a vector containing `e^self` (the exponential function) for each element of\n `self`.",
             &["_self"],
         )
+        .register_documented(
+            "exp2",
+            |_self: Val<::glam::DVec2>| {
+                let output: Val<::glam::DVec2> = {
+                    {
+                        let output: Val<::glam::DVec2> = ::glam::DVec2::exp2(
+                                _self.into_inner(),
+                            )
+                            .into();
+                        output
+                    }
+                };
+                output
+            },
+            " Returns a vector containing `2^self` for each element of `self`.",
+            &["_self"],
+        )
         .register_documented(
             "extend",
             |_self: Val<::glam::DVec2>, z: f64| {
@@ -41777,6 +42083,40 @@ pub(crate) fn register_d_vec_2_functions(world: &mut World) {
             " Performs a linear interpolation between `self` and `rhs` based on the value `s`.\n When `s` is `0.0`, the result will be equal to `self`.  When `s` is `1.0`, the result\n will be equal to `rhs`. When `s` is outside of range `[0, 1]`, the result is linearly\n extrapolated.",
             &["_self", "rhs", "s"],
         )
+        .register_documented(
+            "ln",
+            |_self: Val<::glam::DVec2>| {
+                let output: Val<::glam::DVec2> = {
+                    {
+                        let output: Val<::glam::DVec2> = ::glam::DVec2::ln(
+                                _self.into_inner(),
+                            )
+                            .into();
+                        output
+                    }
+                };
+                output
+            },
+            " Returns a vector containing the natural logarithm for each element of `self`.\n This returns NaN when the element is negative and negative infinity when the element is zero.",
+            &["_self"],
+        )
+        .register_documented(
+            "log2",
+            |_self: Val<::glam::DVec2>| {
+                let output: Val<::glam::DVec2> = {
+                    {
+                        let output: Val<::glam::DVec2> = ::glam::DVec2::log2(
+                                _self.into_inner(),
+                            )
+                            .into();
+                        output
+                    }
+                };
+                output
+            },
+            " Returns a vector containing the base 2 logarithm for each element of `self`.\n This returns NaN when the element is negative and negative infinity when the element is zero.",
+            &["_self"],
+        )
         .register_documented(
             "max",
             |_self: Val<::glam::DVec2>, rhs: Val<::glam::DVec2>| {
@@ -43328,6 +43668,23 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) {
             " Returns a vector containing `e^self` (the exponential function) for each element of\n `self`.",
             &["_self"],
         )
+        .register_documented(
+            "exp2",
+            |_self: Val<::glam::DVec3>| {
+                let output: Val<::glam::DVec3> = {
+                    {
+                        let output: Val<::glam::DVec3> = ::glam::DVec3::exp2(
+                                _self.into_inner(),
+                            )
+                            .into();
+                        output
+                    }
+                };
+                output
+            },
+            " Returns a vector containing `2^self` for each element of `self`.",
+            &["_self"],
+        )
         .register_documented(
             "extend",
             |_self: Val<::glam::DVec3>, w: f64| {
@@ -43412,6 +43769,23 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) {
             " Creates a new vector from an array.",
             &["a"],
         )
+        .register_documented(
+            "from_homogeneous",
+            |v: Val<::glam::DVec4>| {
+                let output: Val<::glam::DVec3> = {
+                    {
+                        let output: Val<::glam::DVec3> = ::glam::DVec3::from_homogeneous(
+                                v.into_inner(),
+                            )
+                            .into();
+                        output
+                    }
+                };
+                output
+            },
+            " Projects a homogeneous coordinate to 3D space by performing perspective divide.\n # Panics\n Will panic if `v.w` is `0` when `glam_assert` is enabled.",
+            &["v"],
+        )
         .register_documented(
             "is_finite",
             |_self: Val<::glam::DVec3>| {
@@ -43576,6 +43950,40 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) {
             " Performs a linear interpolation between `self` and `rhs` based on the value `s`.\n When `s` is `0.0`, the result will be equal to `self`.  When `s` is `1.0`, the result\n will be equal to `rhs`. When `s` is outside of range `[0, 1]`, the result is linearly\n extrapolated.",
             &["_self", "rhs", "s"],
         )
+        .register_documented(
+            "ln",
+            |_self: Val<::glam::DVec3>| {
+                let output: Val<::glam::DVec3> = {
+                    {
+                        let output: Val<::glam::DVec3> = ::glam::DVec3::ln(
+                                _self.into_inner(),
+                            )
+                            .into();
+                        output
+                    }
+                };
+                output
+            },
+            " Returns a vector containing the natural logarithm for each element of `self`.\n This returns NaN when the element is negative and negative infinity when the element is zero.",
+            &["_self"],
+        )
+        .register_documented(
+            "log2",
+            |_self: Val<::glam::DVec3>| {
+                let output: Val<::glam::DVec3> = {
+                    {
+                        let output: Val<::glam::DVec3> = ::glam::DVec3::log2(
+                                _self.into_inner(),
+                            )
+                            .into();
+                        output
+                    }
+                };
+                output
+            },
+            " Returns a vector containing the base 2 logarithm for each element of `self`.\n This returns NaN when the element is negative and negative infinity when the element is zero.",
+            &["_self"],
+        )
         .register_documented(
             "max",
             |_self: Val<::glam::DVec3>, rhs: Val<::glam::DVec3>| {
@@ -44327,6 +44735,23 @@ pub(crate) fn register_d_vec_3_functions(world: &mut World) {
             " Converts `self` to `[x, y, z]`",
             &["_self"],
         )
+        .register_documented(
+            "to_homogeneous",
+            |_self: Val<::glam::DVec3>| {
+                let output: Val<::glam::DVec4> = {
+                    {
+                        let output: Val<::glam::DVec4> = ::glam::DVec3::to_homogeneous(
+                                _self.into_inner(),
+                            )
+                            .into();
+                        output
+                    }
+                };
+                output
+            },
+            " Creates a homogeneous coordinate from `self`, equivalent to `self.extend(1.0)`.",
+            &["_self"],
+        )
         .register_documented(
             "trunc",
             |_self: Val<::glam::DVec3>| {
@@ -45102,6 +45527,23 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) {
             " Returns a vector containing `e^self` (the exponential function) for each element of\n `self`.",
             &["_self"],
         )
+        .register_documented(
+            "exp2",
+            |_self: Val<::glam::DVec4>| {
+                let output: Val<::glam::DVec4> = {
+                    {
+                        let output: Val<::glam::DVec4> = ::glam::DVec4::exp2(
+                                _self.into_inner(),
+                            )
+                            .into();
+                        output
+                    }
+                };
+                output
+            },
+            " Returns a vector containing `2^self` for each element of `self`.",
+            &["_self"],
+        )
         .register_documented(
             "floor",
             |_self: Val<::glam::DVec4>| {
@@ -45332,6 +45774,40 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) {
             " Performs a linear interpolation between `self` and `rhs` based on the value `s`.\n When `s` is `0.0`, the result will be equal to `self`.  When `s` is `1.0`, the result\n will be equal to `rhs`. When `s` is outside of range `[0, 1]`, the result is linearly\n extrapolated.",
             &["_self", "rhs", "s"],
         )
+        .register_documented(
+            "ln",
+            |_self: Val<::glam::DVec4>| {
+                let output: Val<::glam::DVec4> = {
+                    {
+                        let output: Val<::glam::DVec4> = ::glam::DVec4::ln(
+                                _self.into_inner(),
+                            )
+                            .into();
+                        output
+                    }
+                };
+                output
+            },
+            " Returns a vector containing the natural logarithm for each element of `self`.\n This returns NaN when the element is negative and negative infinity when the element is zero.",
+            &["_self"],
+        )
+        .register_documented(
+            "log2",
+            |_self: Val<::glam::DVec4>| {
+                let output: Val<::glam::DVec4> = {
+                    {
+                        let output: Val<::glam::DVec4> = ::glam::DVec4::log2(
+                                _self.into_inner(),
+                            )
+                            .into();
+                        output
+                    }
+                };
+                output
+            },
+            " Returns a vector containing the base 2 logarithm for each element of `self`.\n This returns NaN when the element is negative and negative infinity when the element is zero.",
+            &["_self"],
+        )
         .register_documented(
             "max",
             |_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>| {
@@ -45641,6 +46117,23 @@ pub(crate) fn register_d_vec_4_functions(world: &mut World) {
             " Returns a vector containing each element of `self` raised to the power of `n`.",
             &["_self", "n"],
         )
+        .register_documented(
+            "project",
+            |_self: Val<::glam::DVec4>| {
+                let output: Val<::glam::DVec3> = {
+                    {
+                        let output: Val<::glam::DVec3> = ::glam::DVec4::project(
+                                _self.into_inner(),
+                            )
+                            .into();
+                        output
+                    }
+                };
+                output
+            },
+            " Projects a homogeneous coordinate to 3D space by performing perspective divide.\n # Panics\n Will panic if `self.w` is `0` when `glam_assert` is enabled.",
+            &["_self"],
+        )
         .register_documented(
             "project_onto",
             |_self: Val<::glam::DVec4>, rhs: Val<::glam::DVec4>| {
@@ -56557,7 +57050,7 @@ pub(crate) fn register_uuid_functions(world: &mut World) {
                 };
                 output
             },
-            " Creates a UUID using the supplied bytes in little endian order.\n The individual fields encoded in the buffer will be flipped.\n # Examples\n Basic usage:\n ```\n # fn main() -> Result<(), uuid::Error> {\n # use uuid::Uuid;\n let bytes = [\n     0xa1, 0xa2, 0xa3, 0xa4,\n     0xb1, 0xb2,\n     0xc1, 0xc2,\n     0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8,\n ];\n let uuid = Uuid::from_bytes_le(bytes);\n assert_eq!(\n     \"a4a3a2a1-b2b1-c2c1-d1d2-d3d4d5d6d7d8\",\n     uuid.hyphenated().to_string(),\n );\n # Ok(())\n # }\n ```",
+            " Creates a UUID using the supplied bytes in little endian order.\n Note that ordering is applied to each _field_, rather than to the bytes as a whole.\n This ordering is compatible with Microsoft's mixed endian GUID format.\n # Examples\n Basic usage:\n ```\n # fn main() -> Result<(), uuid::Error> {\n # use uuid::Uuid;\n let bytes = [\n     0xa1, 0xa2, 0xa3, 0xa4,\n     0xb1, 0xb2,\n     0xc1, 0xc2,\n     0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8,\n ];\n let uuid = Uuid::from_bytes_le(bytes);\n assert_eq!(\n     \"a4a3a2a1-b2b1-c2c1-d1d2-d3d4d5d6d7d8\",\n     uuid.hyphenated().to_string(),\n );\n # Ok(())\n # }\n ```",
             &["b"],
         )
         .register_documented(
@@ -56737,7 +57230,7 @@ pub(crate) fn register_uuid_functions(world: &mut World) {
                 };
                 output
             },
-            " Returns the bytes of the UUID in little-endian order.\n The bytes will be flipped to convert into little-endian order. This is\n based on the endianness of the UUID, rather than the target environment\n so bytes will be flipped on both big and little endian machines.\n # Examples\n ```\n use uuid::Uuid;\n # fn main() -> Result<(), uuid::Error> {\n let uuid = Uuid::parse_str(\"a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8\")?;\n assert_eq!(\n     uuid.to_bytes_le(),\n     ([\n         0xa4, 0xa3, 0xa2, 0xa1, 0xb2, 0xb1, 0xc2, 0xc1, 0xd1, 0xd2,\n         0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8\n     ])\n );\n # Ok(())\n # }\n ```",
+            " Returns the bytes of the UUID in little-endian order.\n The bytes for each field will be flipped to convert into little-endian order.\n This is based on the endianness of the UUID, rather than the target environment\n so bytes will be flipped on both big and little endian machines.\n Note that ordering is applied to each _field_, rather than to the bytes as a whole.\n This ordering is compatible with Microsoft's mixed endian GUID format.\n # Examples\n ```\n use uuid::Uuid;\n # fn main() -> Result<(), uuid::Error> {\n let uuid = Uuid::parse_str(\"a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8\")?;\n assert_eq!(\n     uuid.to_bytes_le(),\n     ([\n         0xa4, 0xa3, 0xa2, 0xa1, 0xb2, 0xb1, 0xc2, 0xc1, 0xd1, 0xd2,\n         0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8\n     ])\n );\n # Ok(())\n # }\n ```",
             &["_self"],
         )
         .register_documented(